Strategies for Generating Subtransactions of an Independent Transaction

A transaction is a collection of operations that performs a single logical function in a database application. Each transaction is a unit of both atomicity and consistency. Thus, transactions are required not to violate any database consistency constraints. In most cases, the update operations in a transaction are executed sequentially. The effect of a single operation in a transaction potentially may be changed by another operation in the same transaction. This implies that the sequential execution sometimes does some redundant work. It is the transaction designer’s responsibility to define properly the various transactions so that it preserves the consistency of the database. In the literature, three types of fault have been identified in transactions, namely: inefficient, unsafe and unreliable. In this paper, we present the strategies that can be applied to generate subtransactions to exploit parallelism. In our work, we have identified five types of relationship which can occur in a transaction. They are: redundancy, subsumption, dependent, partly dependent and independent. By analysing these relationships, the transaction can be improved and inefficient transactions can be avoided. Furthermore, generating subtransactions and executing them in parallel can reduce the execution time.